// 集成测试 - AkShare 期权接口
// 
// 本文件包含所有已实现接口的集成测试
// 测试会实际调用 API，请确保网络连接正常

use akoption::*;

// ============ 东方财富接口测试 ============

/// 测试：东方财富-期权市场快照
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据量 > 0
/// 3. 数据结构完整（包含必要字段）
#[tokio::test]
#[ignore] // 默认忽略，需要网络连接时手动运行
async fn test_option_current_em() {
    let result = option_current_em().await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取 {} 条期权数据", data.len());
            
            if data.is_empty() {
                println!("  ⚠️  警告：返回数据为空，可能是非交易时间或API无数据");
            } else {
                // 验证第一条数据的结构
                let first = &data[0];
                assert!(!first.code.is_empty(), "期权代码为空");
                assert!(!first.name.is_empty(), "期权名称为空");
                
                // 打印前3条数据示例
                for (i, item) in data.iter().take(3).enumerate() {
                    println!("  [{}] {} - {}: 最新价={:?}, 成交量={:?}", 
                             i+1, item.code, item.name, item.last, item.volume);
                }
            }
        }
        Err(e) => {
            // 打印详细错误信息用于调试
            println!("  ❌ API 调用失败: {:?}", e);
            println!("  错误详情: {}", e);
            
            // 网络错误不算测试失败,只是警告
            let err_msg = e.to_string();
            if err_msg.contains("connection closed") || err_msg.contains("timeout") 
                || err_msg.contains("error sending request") || err_msg.contains("SendRequest") {
                println!("  ⚠️  网络连接问题,跳过测试");
            } else {
                panic!("API 调用失败: {:?}", e);
            }
        }
    }
}

/// 测试：东方财富-期权价值分析
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据包含价值分析字段
#[tokio::test]
#[ignore]
async fn test_option_value_analysis_em() {
    let result = option_value_analysis_em().await;
    
    match result {
        Ok(data) => {
            assert!(!data.is_empty(), "返回数据为空");
            
            // 验证数据结构
            let first = &data[0];
            assert!(!first.code.is_empty(), "期权代码为空");
            assert!(!first.name.is_empty(), "期权名称为空");
            // 价值分析字段可能为 None（非交易时间）
            
            println!("✓ 成功获取 {} 条价值分析数据", data.len());
            
            // 打印前3条数据示例
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {}: 内在价值={:?}, 时间价值={:?}", 
                         i+1, item.name, item.intrinsic_value, item.time_value);
            }
        }
        Err(e) => {
            let err_msg = e.to_string();
            if err_msg.contains("connection closed") || err_msg.contains("timeout") 
                || err_msg.contains("error sending request") || err_msg.contains("SendRequest") {
                println!("  ⚠️  网络连接问题,跳过测试");
            } else {
                panic!("API 调用失败: {:?}", e);
            }
        }
    }
}

/// 测试：东方财富-期权风险分析
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据包含 Greeks 指标
#[tokio::test]
#[ignore]
async fn test_option_risk_analysis_em() {
    let result = option_risk_analysis_em().await;
    
    match result {
        Ok(data) => {
            assert!(!data.is_empty(), "返回数据为空");
            
            let first = &data[0];
            assert!(!first.code.is_empty(), "期权代码为空");
            
            println!("✓ 成功获取 {} 条风险分析数据", data.len());
            
            // 打印前3条 Greeks 数据
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {}: Delta={:?}, Gamma={:?}, Vega={:?}", 
                         i+1, item.name, item.delta, item.gamma, item.vega);
            }
        }
        Err(e) => {
            let err_msg = e.to_string();
            if err_msg.contains("connection closed") || err_msg.contains("timeout") 
                || err_msg.contains("error sending request") || err_msg.contains("SendRequest") {
                println!("  ⚠️  网络连接问题,跳过测试");
            } else {
                panic!("API 调用失败: {:?}", e);
            }
        }
    }
}

/// 测试：东方财富-期权折溢价分析
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据包含折溢价字段
#[tokio::test]
#[ignore]
async fn test_option_premium_analysis_em() {
    let result = option_premium_analysis_em().await;
    
    match result {
        Ok(data) => {
            assert!(!data.is_empty(), "返回数据为空");
            
            println!("✓ 成功获取 {} 条折溢价分析数据", data.len());
            
            // 打印前3条数据
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {}: 折溢价率={:?}%, 盈亏平衡价={:?}", 
                         i+1, item.name, item.premium_rate, item.break_even);
            }
        }
        Err(e) => {
            let err_msg = e.to_string();
            if err_msg.contains("connection closed") || err_msg.contains("timeout") 
                || err_msg.contains("error sending request") || err_msg.contains("SendRequest") {
                println!("  ⚠️  网络连接问题,跳过测试");
            } else {
                panic!("API 调用失败: {:?}", e);
            }
        }
    }
}

/// 测试：东方财富-期权分时行情
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据包含分时字段
/// 
/// 注意：需要提供有效的期权代码
#[tokio::test]
#[ignore]
async fn test_option_minute_em() {
    // 使用一个常见的期权代码进行测试
    let symbol = "MO2511-C-3800"; // 沪深300期权
    
    let result = option_minute_em(symbol).await;
    
    // 分时数据可能为空（非交易时间或无数据）
    if let Ok(data) = result {
        println!("✓ 成功获取 {} 条分时数据", data.len());
        
        if !data.is_empty() {
            // 打印前5条数据
            for (i, item) in data.iter().take(5).enumerate() {
                println!("  [{}] {}: 价格={:?}, 成交量={:?}", 
                         i+1, item.time, item.close, item.volume);
            }
        } else {
            println!("  注意：当前无分时数据（可能是非交易时间）");
        }
    } else {
        println!("  警告：分时数据获取失败，可能是合约代码无效或 API 变更");
    }
}

// ============ 上交所/深交所接口测试 ============

/// 测试：上交所-当日合约
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的合约数量 > 0
/// 3. 合约信息完整
#[tokio::test]
#[ignore]
async fn test_option_current_day_sse() {
    let result = option_current_day_sse().await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    assert!(!data.is_empty(), "返回数据为空");
    
    // 验证数据结构
    let first = &data[0];
    assert!(!first.contract_code.is_empty(), "合约编码为空");
    assert!(!first.contract_name.is_empty(), "合约简称为空");
    
    println!("✓ 成功获取 {} 个上交所合约", data.len());
    
    // 打印前5个合约
    for (i, item) in data.iter().take(5).enumerate() {
        println!("  [{}] {} - {} ({})", 
                 i+1, item.contract_code, item.contract_name, item.option_type);
    }
}

/// 测试：上交所-每日统计
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的统计数据包含各标的
/// 
/// 注意：需要提供有效的交易日期
#[tokio::test]
#[ignore]
async fn test_option_daily_stats_sse() {
    // 使用最近的交易日
    let date = "20241025";
    
    let result = option_daily_stats_sse(date).await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    assert!(!data.is_empty(), "返回数据为空");
    
    println!("✓ 成功获取 {} 个标的的统计数据", data.len());
    
    // 打印所有标的统计
    for (i, item) in data.iter().enumerate() {
        println!("  [{}] {} ({}): 总成交量={:?}, 总持仓={:?}", 
                 i+1, item.underlying_name, item.underlying_code,
                 item.total_volume, item.total_open_interest);
    }
}

/// 测试：上交所-风险指标
/// 
/// 验证点：
/// 1. 能够成功获取数据
/// 2. 返回的数据包含风险指标字段
#[tokio::test]
#[ignore]
async fn test_option_risk_indicator_sse() {
    let date = "20241025";
    
    let result = option_risk_indicator_sse(date).await;
    
    // 风险指标可能为空（非交易日或无数据）
    if let Ok(data) = result {
        println!("✓ 成功获取 {} 条风险指标数据", data.len());
        
        if !data.is_empty() {
            // 打印前5条数据
            for (i, item) in data.iter().take(5).enumerate() {
                println!("  [{}] {}: Delta={:?}, Gamma={:?}", 
                         i+1, item.security_id, item.delta, item.gamma);
            }
        }
    } else {
        println!("  注意：风险指标数据获取失败或为空");
    }
}

/// 测试：深交所-当日合约
/// 
/// 注意：此 API 当前已失效，测试预期会失败
#[tokio::test]
#[ignore]
async fn test_option_current_day_szse() {
    let result = option_current_day_szse().await;
    
    if result.is_ok() {
        let data = result.unwrap();
        println!("✓ 成功获取 {} 个深交所合约", data.len());
    } else {
        println!("  ⚠️  深交所 API 已失效（预期行为）");
    }
}

/// 测试：深交所-每日统计
/// 
/// 注意：此 API 当前已失效，测试预期会失败
#[tokio::test]
#[ignore]
async fn test_option_daily_stats_szse() {
    let date = "20241025";
    let result = option_daily_stats_szse(date).await;
    
    if result.is_ok() {
        let data = result.unwrap();
        println!("✓ 成功获取 {} 个标的的统计数据", data.len());
    } else {
        println!("  ⚠️  深交所 API 已失效（预期行为）");
    }
}

// ============ 新浪财经-中金所接口测试 ============

/// 测试：新浪-上证50合约列表
/// 
/// 验证点：
/// 1. 能够成功获取合约列表
/// 2. 返回的合约数量 > 0
/// 3. 合约代码格式正确（以 ho 开头）
#[tokio::test]
#[ignore]
async fn test_option_cffex_sz50_list_sina() {
    let result = option_cffex_sz50_list_sina().await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let contracts = result.unwrap();
    assert!(!contracts.is_empty(), "返回合约列表为空");
    
    // 验证合约代码格式
    for contract in &contracts {
        assert!(contract.starts_with("ho"), "合约代码格式错误: {}", contract);
    }
    
    println!("✓ 成功获取 {} 个上证50期权合约", contracts.len());
    println!("  合约列表: {:?}", contracts);
}

/// 测试：新浪-上证50实时行情
/// 
/// 验证点：
/// 1. 能够成功获取T型报价数据
/// 2. 返回的数据包含看涨和看跌期权
#[tokio::test]
#[ignore]
async fn test_option_cffex_sz50_spot_sina() {
    // 先获取合约列表
    let contracts = option_cffex_sz50_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    // 使用第一个合约测试
    let symbol = &contracts[0];
    let result = option_cffex_sz50_spot_sina(symbol).await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    assert_eq!(data.symbol, *symbol, "合约代码不匹配");
    assert!(!data.contracts.is_empty(), "T型报价数据为空");
    
    println!("✓ 成功获取合约 {} 的T型报价", symbol);
    println!("  共 {} 个行权价", data.contracts.len());
    
    // 打印前3个行权价的数据
    for (i, contract) in data.contracts.iter().take(3).enumerate() {
        println!("  [{}] 行权价={:?}: 看涨={}, 看跌={}", 
                 i+1, contract.strike, 
                 contract.call_symbol, contract.put_symbol);
    }
}

/// 测试：新浪-上证50日频数据
/// 
/// 验证点：
/// 1. 能够成功获取历史数据
/// 2. 返回的数据包含OHLCV字段
#[tokio::test]
#[ignore]
async fn test_option_cffex_sz50_daily_sina() {
    let contracts = option_cffex_sz50_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    let symbol = &contracts[0];
    let result = option_cffex_sz50_daily_sina(symbol).await;
    
    if let Ok(data) = result {
        println!("✓ 成功获取合约 {} 的 {} 条历史数据", symbol, data.len());
        
        if !data.is_empty() {
            // 打印最近5条数据
            for (i, item) in data.iter().rev().take(5).enumerate() {
                println!("  [{}] {}: 开={:?}, 高={:?}, 低={:?}, 收={:?}, 量={:?}", 
                         i+1, item.date, item.open, item.high, 
                         item.low, item.close, item.volume);
            }
        }
    } else {
        println!("  注意：日频数据获取失败（可能是新合约无历史数据）");
    }
}

/// 测试：新浪-沪深300合约列表
#[tokio::test]
#[ignore]
async fn test_option_cffex_hs300_list_sina() {
    let result = option_cffex_hs300_list_sina().await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let contracts = result.unwrap();
    assert!(!contracts.is_empty(), "返回合约列表为空");
    
    // 验证合约代码格式（以 mo 开头）
    for contract in &contracts {
        assert!(contract.starts_with("mo"), "合约代码格式错误: {}", contract);
    }
    
    println!("✓ 成功获取 {} 个沪深300期权合约", contracts.len());
    println!("  合约列表: {:?}", contracts);
}

/// 测试：新浪-沪深300实时行情
#[tokio::test]
#[ignore]
async fn test_option_cffex_hs300_spot_sina() {
    let contracts = option_cffex_hs300_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    let symbol = &contracts[0];
    let result = option_cffex_hs300_spot_sina(symbol).await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    println!("✓ 成功获取合约 {} 的T型报价，共 {} 个行权价", 
             symbol, data.contracts.len());
}

/// 测试：新浪-沪深300日频数据
#[tokio::test]
#[ignore]
async fn test_option_cffex_hs300_daily_sina() {
    let contracts = option_cffex_hs300_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    let symbol = &contracts[0];
    let result = option_cffex_hs300_daily_sina(symbol).await;
    
    if let Ok(data) = result {
        println!("✓ 成功获取合约 {} 的 {} 条历史数据", symbol, data.len());
    } else {
        println!("  注意：日频数据获取失败");
    }
}

/// 测试：新浪-中证1000合约列表
#[tokio::test]
#[ignore]
async fn test_option_cffex_zz1000_list_sina() {
    let result = option_cffex_zz1000_list_sina().await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let contracts = result.unwrap();
    assert!(!contracts.is_empty(), "返回合约列表为空");
    
    // 验证合约代码格式（以 io 开头）
    for contract in &contracts {
        assert!(contract.starts_with("io"), "合约代码格式错误: {}", contract);
    }
    
    println!("✓ 成功获取 {} 个中证1000期权合约", contracts.len());
    println!("  合约列表: {:?}", contracts);
}

/// 测试：新浪-中证1000实时行情
#[tokio::test]
#[ignore]
async fn test_option_cffex_zz1000_spot_sina() {
    let contracts = option_cffex_zz1000_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    let symbol = &contracts[0];
    let result = option_cffex_zz1000_spot_sina(symbol).await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    println!("✓ 成功获取合约 {} 的T型报价，共 {} 个行权价", 
             symbol, data.contracts.len());
}

/// 测试：新浪-中证1000日频数据
#[tokio::test]
#[ignore]
async fn test_option_cffex_zz1000_daily_sina() {
    let contracts = option_cffex_zz1000_list_sina().await.unwrap();
    assert!(!contracts.is_empty(), "无可用合约");
    
    let symbol = &contracts[0];
    let result = option_cffex_zz1000_daily_sina(symbol).await;
    
    if let Ok(data) = result {
        println!("✓ 成功获取合约 {} 的 {} 条历史数据", symbol, data.len());
    } else {
        println!("  注意：日频数据获取失败");
    }
}

// ============ 基础接口测试 ============

/// 测试：期权看板
/// 
/// 验证点：
/// 1. 能够成功获取看板数据
/// 2. 返回的数据包含期权合约信息
#[tokio::test]
#[ignore]
async fn test_option_finance_board() {
    use akoption::types::{FinanceSymbol, EndMonth};
    
    let result = option_finance_board(
        FinanceSymbol::Sse50Etf,
        EndMonth::new("2511"),
    ).await;
    
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    println!("✓ 成功获取 {} 条看板数据", data.len());
    
    if !data.is_empty() {
        let first = &data[0];
        println!("  示例: {} - 最新价={:?}", first.contract_id, first.last);
    }
}

/// 测试：上交所标的物快照
/// 
/// 验证点：
/// 1. 能够成功获取标的物数据
/// 2. 返回的数据包含标的信息
#[tokio::test]
#[ignore]
async fn test_option_finance_sse_underlying() {
    use akoption::types::SseUnderlying;
    
    let result = option_finance_sse_underlying(SseUnderlying::HuaXia50).await;
    assert!(result.is_ok(), "API 调用失败: {:?}", result.err());
    
    let data = result.unwrap();
    println!("✓ 成功获取标的物快照");
    println!("  最新价: {:?}", data.last);
}

// ============ 新浪上交所扩展接口测试 ============

/// 测试：上交所期权合约列表
#[tokio::test]
#[ignore]
async fn test_option_sse_list_sina() {
    let result = option_sse_list_sina("50ETF").await;
    
    match result {
        Ok(months) => {
            assert!(!months.is_empty(), "返回数据为空");
            
            println!("✓ 成功获取 {} 个到期月份", months.len());
            println!("  到期月份列表: {:?}", months);
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所到期日列表
#[tokio::test]
#[ignore]
async fn test_option_sse_expire_day_sina() {
    let result = option_sse_expire_day_sina("202511", "50ETF").await;
    
    match result {
        Ok((expire_day, remainder_days)) => {
            println!("✓ 成功获取到期信息");
            println!("  到期日: {}", expire_day);
            println!("  剩余天数: {}", remainder_days);
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所指定到期日的合约代码
#[tokio::test]
#[ignore]
async fn test_option_sse_codes_sina() {
    // 直接按实现要求提供参数：期权类型、到期月份、标的代码
    let result = option_sse_codes_sina("看涨期权", "202511", "510050").await;
    
    match result {
        Ok(data) => {
            println!("✓ 到期月 {} (标的 {}) 的看涨合约数: {}", "202511", "510050", data.len());
            
            for (i, (_idx, code)) in data.iter().take(5).enumerate() {
                println!("  [{}] {}", i+1, code);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所期权实时价格
#[tokio::test]
#[ignore]
async fn test_option_sse_spot_price_sina() {
    // 使用一个示例合约代码
    let contract_code = "10010170";
    let result = option_sse_spot_price_sina(contract_code).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取合约 {} 的实时价格", contract_code);
            println!("  最新价: {:?}", data.last);
            println!("  涨跌幅: {:?}%", data.change_pct);
            println!("  成交量: {:?}", data.volume);
            println!("  持仓量: {:?}", data.open_interest);
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所标的实时价格
#[tokio::test]
#[ignore]
async fn test_option_sse_underlying_spot_price_sina() {
    let underlying_code = "sh510500";
    let result = option_sse_underlying_spot_price_sina(underlying_code).await;
    
    match result {
        Ok(price) => {
            println!("✓ 成功获取标的 {} 的实时价格: {}", underlying_code, price);
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所期权Greeks指标
#[tokio::test]
#[ignore]
async fn test_option_sse_greeks_sina() {
    let contract_code = "10010074";
    let result = option_sse_greeks_sina(contract_code).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取合约 {} 的Greeks指标", contract_code);
            println!("{:#?}", data);
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所期权分时数据
#[tokio::test]
#[ignore]
async fn test_option_sse_minute_sina() {
    let contract_code = "10010074";
    let result = option_sse_minute_sina(contract_code).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取合约 {} 的分时数据: {} 条", contract_code, data.len());
            
            // 打印前5条完整结构，便于校验字段解析
            for (i, item) in data.iter().take(5).enumerate() {
                println!("  [{}] {:#?}", i+1, item);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上交所期权日线数据
#[tokio::test]
#[ignore]
async fn test_option_sse_daily_sina() {
    let contract_code = "10010074";
    let result = option_sse_daily_sina(contract_code).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取合约 {} 的日线数据: {} 条", contract_code, data.len());
            
            // 打印最近3天的数据
            for (i, item) in data.iter().take(3).enumerate() {
              println!("{:?}", item);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：金融期权分时数据
#[tokio::test]
#[ignore]
async fn test_option_finance_minute_sina() {
    let symbol = "10010074";
    let result = option_finance_minute_full_sina(symbol).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取金融期权分时数据: {} 条", data.len());

            for(_i, item) in data.iter().take(5).enumerate() {
                println!("  {:#?}", item);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }        
    }

}

// ============ 商品期权接口测试 ============

/// 测试：新浪商品期权合约信息
#[tokio::test]
#[ignore]
async fn test_option_commodity_contract_sina() {
    let symbol = "cu2501";
    let result = option_commodity_contract_sina(symbol).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取商品期权 {} 的合约信息: {} 个", symbol, data.len());
            
            // 打印前3个合约
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - {} (行权价: {:?})", 
                         i+1, item.contract_code, item.contract_name, item.strike);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：新浪商品期权T型报价
#[tokio::test]
#[ignore]
async fn test_option_commodity_contract_table_sina() {
    let symbol = "cu2501";
    let result = option_commodity_contract_table_sina(symbol).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取商品期权 {} 的T型报价: {} 行", symbol, data.len());
            
            // 打印前3行
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] 行权价: {:?}", i+1, item.strike);
                println!("      看涨: {} - 最新价:{:?}", item.call_code, item.call_last);
                println!("      看跌: {} - 最新价:{:?}", item.put_code, item.put_last);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：新浪商品期权历史数据
#[tokio::test]
#[ignore]
async fn test_option_commodity_hist_sina() {
    let symbol = "cu2501C6000";
    let result = option_commodity_hist_sina(symbol).await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取商品期权 {} 的历史数据: {} 条", symbol, data.len());
            
            // 打印最近3天
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - 开:{:?} 高:{:?} 低:{:?} 收:{:?}", 
                         i+1, item.date, item.open, item.high, item.low, item.close);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

// ============ 商品期权交易所接口测试 ============

/// 测试：上期所商品期权历史数据
#[tokio::test]
#[ignore]
async fn test_option_hist_shfe() {
    let result = option_hist_shfe("cu2501C6000", "20241001", "20241031").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取上期所历史数据: {} 条", data.len());
            
            // 打印前3条
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - {} - 收盘:{:?} 成交量:{:?}", 
                         i+1, item.date, item.contract_code, item.close, item.volume);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：上期所隐含波动率
#[tokio::test]
#[ignore]
async fn test_option_vol_shfe() {
    let result = option_vol_shfe("cu2501", "20241028").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取上期所隐含波动率: {} 条", data.len());
            
            // 打印前3条
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - 隐含波动率:{:?}", 
                         i+1, item.contract_code, item.implied_volatility);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：大商所商品期权历史数据
#[tokio::test]
#[ignore]
async fn test_option_hist_dce() {
    let result = option_hist_dce("m2501-C-3000", "20241001", "20241031").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取大商所历史数据: {} 条", data.len());
            
            // 打印前3条
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - {} - 收盘:{:?}", 
                         i+1, item.date, item.contract_code, item.close);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：郑商所商品期权历史数据
#[tokio::test]
#[ignore]
async fn test_option_hist_czce() {
    let result = option_hist_czce("SR501C6000", "20241028").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取郑商所历史数据: {} 条", data.len());
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：郑商所年度历史数据
#[tokio::test]
#[ignore]
async fn test_option_czce_hist() {
    let result = option_czce_hist("2024").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取郑商所2024年历史数据: {} 条", data.len());
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：广期所商品期权历史数据
#[tokio::test]
#[ignore]
async fn test_option_hist_gfex() {
    let result = option_hist_gfex("SI2501", "20241028").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取广期所历史数据: {} 条", data.len());
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：广期所隐含波动率
#[tokio::test]
#[ignore]
async fn test_option_vol_gfex() {
    let result = option_vol_gfex("SI2501", "20241028").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取广期所隐含波动率: {} 条", data.len());
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

// ============ 其他辅助接口测试 ============

/// 测试：期权手续费信息
#[tokio::test]
#[ignore]
async fn test_option_comm_info() {
    let result = option_comm_info().await;
    
    match result {
        Ok(data) => {
            assert!(!data.is_empty(), "返回数据为空");
            
            println!("✓ 成功获取期权手续费信息: {} 条", data.len());
            
            // 打印所有手续费信息
            for item in data.iter() {
                println!("  {} - {}: 开仓:{:?} 平仓:{:?} {}", 
                         item.exchange, item.product, 
                         item.open_fee, item.close_fee, item.fee_unit);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：期权保证金信息
#[tokio::test]
#[ignore]
async fn test_option_margin() {
    let result = option_margin().await;
    
    match result {
        Ok(data) => {
            assert!(!data.is_empty(), "返回数据为空");
            
            println!("✓ 成功获取期权保证金信息: {} 条", data.len());
            
            // 打印所有保证金信息
            for item in data.iter() {
                println!("  {} - {}: 保证金比例:{:?}%", 
                         item.exchange, item.product, item.margin_rate);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

/// 测试：东方财富期权龙虎榜
#[tokio::test]
#[ignore]
async fn test_option_lhb_em() {
    let result = option_lhb_em("510300", "期权持仓情况-认沽持仓量", "20220121").await;
    
    match result {
        Ok(data) => {
            println!("✓ 成功获取期权龙虎榜数据: {} 条", data.len());
            
            // 打印前3条
            for (i, item) in data.iter().take(3).enumerate() {
                println!("  [{}] {} - {} - 持仓量:{:?}", 
                         i+1, item.contract_code, item.contract_name, item.open_interest);
            }
        }
        Err(e) => {
            println!("  ⚠️  API调用失败: {}", e);
        }
    }
}

// ============ 测试工具函数 ============

/// 运行所有测试的辅助函数
/// 
/// 使用方法：
/// ```bash
/// cargo test --test integration_tests -- --ignored --nocapture
/// ```
#[tokio::test]
#[ignore]
async fn run_all_tests() {
    println!("\n========================================");
    println!("  AkShare 期权接口集成测试");
    println!("  总计: 52个接口");
    println!("========================================\n");
    
    // 这个测试会被单独运行，用于手动触发所有测试
    println!("请使用以下命令运行所有测试：");
    println!("cargo test --test integration_tests -- --ignored --nocapture");
    println!("\n或运行特定测试：");
    println!("cargo test --test integration_tests test_option_sse_list_sina -- --ignored --nocapture");
}
